home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / a_utils / decomp.lha / decomp / machine.h < prev    next >
Text File  |  1988-01-12  |  16KB  |  369 lines
  1. /*
  2.  * Module: machine.h
  3.  *
  4.  * Author: J. Reuter
  5.  *
  6.  * This include file contains symbolic names for the VAX machine
  7.  * instructions.  It also defines the structure of the opcode[]
  8.  * array and contains symbolic names and macros used to analyze
  9.  * addressing modes, data types, and access types.
  10.  
  11. /*
  12.  * The following O_ constants are symbolic names for the Vax opcodes.
  13.  */
  14. #define O_HALT 0x00        /* halt */
  15. #define O_NOP 0x01        /* no operation */
  16. #define O_REI 0x02        /* return from exception or interrupt */
  17. #define O_BPT 0x03        /* break point fault */
  18. #define O_RET 0x04        /* return from called procedure */
  19. #define O_RSB 0x05        /* return from subroutine */
  20. #define O_LDPCTX 0x06        /* load process context */
  21. #define O_SVPCTX 0x07        /* save process context */
  22. #define O_CVTPS 0x08        /* convert packed to leading separate numeric */
  23. #define O_CVTSP 0x09        /* convert leading separate numeric to packed */
  24. #define O_INDEX 0x0A        /* compute index */
  25. #define O_CRC 0x0B        /* calculate cyclic redundancy check */
  26. #define O_PROBER 0x0C        /* probe read access */
  27. #define O_PROBEW 0x0D        /* probe write access */
  28. #define O_INSQUE 0x0E        /* insert into queue */
  29. #define O_REMQUE 0x0F        /* remove from queue */
  30. #define O_BSBB 0x10        /* branch to subroutine with byte disp */
  31. #define O_BRB 0x11        /* branch with byte disp */
  32. #define O_BNEQ 0x12        /* branch on not equal (also BNEQU) */
  33. #define O_BEQL 0x13        /* branch on equal (also BEQLU */
  34. #define O_BGTR 0x14        /* branch on greater */
  35. #define O_BLEQ 0x15        /* branch on less or equal */
  36. #define O_JSB 0x16        /* jump to subroutine */
  37. #define O_JMP 0x17        /* jump */
  38. #define O_BGEQ 0x18        /* branch on greater or equal */
  39. #define O_BLSS 0x19        /* branch on less */
  40. #define O_BGTRU 0x1A        /* branch on greater unsigned */
  41. #define O_BLEQU 0x1B        /* branch on less of equal unsigned */
  42. #define O_BVC 0x1C        /* branch on overflow clear */
  43. #define O_BVS 0x1D        /* branch on overflow set */
  44. #define O_BCC 0x1E        /* branch on carry clear (also BGEQU) */
  45. #define O_BCS 0x1F        /* branch on carry set (also BLSSU) */
  46. #define O_ADDP4 0x20        /* add packed 4 operand */
  47. #define O_ADDP6 0x21        /* add packed 6 operand */
  48. #define O_SUBP4 0x22        /* subtract packed 4 operand */
  49. #define O_SUBP6 0x23        /* subtract packed 6 operand */
  50. #define O_CVTPT 0x24        /* convert packed to trailing numeric */
  51. #define O_MULP 0x25        /* multiply packed */
  52. #define O_CVTTP 0x26        /* convert trailing numeric to packed */
  53. #define O_DIVP 0x27        /* divide packed */
  54. #define O_MOVC3 0x28        /* move character 3 operand */
  55. #define O_CMPC3 0x29        /* compare character 3 operand */
  56. #define O_SCANC 0x2A        /* scan for character */
  57. #define O_SPANC 0x2B        /* span characters */
  58. #define O_MOVC5 0x2C        /* move character 5 operand */
  59. #define O_CMPC5 0x2D        /* compare character 5 operand */
  60. #define O_MOVTC 0x2E        /* move translated characters */
  61. #define O_MOVTUC 0x2F        /* move translated until character */
  62. #define O_BSBW 0x30        /* branch to subroutine with word disp */
  63. #define O_BRW 0x31        /* branch with word disp */
  64. #define O_CVTWL 0x32        /* convert word to long */
  65. #define O_CVTWB 0x33        /* convert word to byte */
  66. #define O_MOVP 0x34        /* move packed */
  67. #define O_CMPP3 0x35        /* compare packed 3 operand */
  68. #define O_CVTPL 0x36        /* convert packed to long */
  69. #define O_CMPP4 0x37        /* compare packed 4 operand */
  70. #define O_EDITPC 0x38        /* edit packed to character */
  71. #define O_MATCHC 0x39        /* match characters */
  72. #define O_LOCC 0x3A        /* locate characters */
  73. #define O_SKPC 0x3B        /* skip character */
  74. #define O_MOVZWL 0x3C        /* move zero-extended word to long */
  75. #define O_ACBW 0x3D        /* add compare and branch word */
  76. #define O_MOVAW 0x3E        /* move address of word */
  77. #define O_PUSHAW 0x3F        /* push address of word */
  78. #define O_ADDF2 0x40        /* add floating 2 operand */
  79. #define O_ADDF3 0x41        /* add floating 3 operand */
  80. #define O_SUBF2 0x42        /* subtract floating 2 operand */
  81. #define O_SUBF3 0x43        /* subtract floating 3 operand */
  82. #define O_MULF2 0x44        /* multiply floating 2 operand */
  83. #define O_MULF3 0x45        /* multiply floating 3 operand */
  84. #define O_DIVF2 0x46        /* divide floating 2 operand */
  85. #define O_DIVF3 0x47        /* divide floating 3 operand */
  86. #define O_CVTFB 0x48        /* convert float to byte */
  87. #define O_CVTFW 0x49        /* convert float to word */
  88. #define O_CVTFL 0x4A        /* convert float to long */
  89. #define O_CVTRFL 0x4B        /* convert rounded float to long */
  90. #define O_CVTBF 0x4C        /* convert byte to float */
  91. #define O_CVTWF 0x4D        /* convert word to float */
  92. #define O_CVTLF 0x4E        /* convert long to float */
  93. #define O_ACBF 0x4F        /* add compare and branch floating */
  94. #define O_MOVF 0x50        /* move float */
  95. #define O_CMPF 0x51        /* compare floating */
  96. #define O_MNEGF 0x52        /* move negated floating */
  97. #define O_TSTF 0x53        /* test float */
  98. #define O_EMODF 0x54        /* extended modulus floating */
  99. #define O_POLYF 0x55        /* evaluate polynomial floating */
  100. #define O_CVTFD 0x56        /* convert float to double */
  101. #define O_DUMMY57 0x57        /* RESERVED to DIGITAL */
  102. #define O_ADAWI 0x58        /* add aligned word interlocked */
  103. #define O_DUMMY59 0x59        /* RESERVED to DIGITAL */
  104. #define O_DUMMY5a 0x5A        /* RESERVED to DIGITAL */
  105. #define O_DUMMY5b 0x5B        /* RESERVED to DIGITAL */
  106. #define O_INSQHI 0x5C        /* insert into queue head, interlocked */
  107. #define O_INSQTI 0x5D        /* insert into queue tail, interlocked */
  108. #define O_REMQHI 0x5E        /* remove from queue head, interlocked */
  109. #define O_REMQTI 0x5F        /* remove from queue tail, interlocked */
  110. #define O_ADDD2 0x60        /* add double 2 operand */
  111. #define O_ADDD3 0x61        /* add double 3 operand */
  112. #define O_SUBD2 0x62        /* subtract double 2 operand */
  113. #define O_SUBD3 0x63        /* subtrace double 3 operand */
  114. #define O_MULD2 0x64        /* multiply double 2 operand */
  115. #define O_MULD3 0x65        /* multiply double 3 operand */
  116. #define O_DIVD2 0x66        /* divide double 2 operand */
  117. #define O_DIVD3 0x67        /* divide double 3 operand */
  118. #define O_CVTDB 0x68        /* convert double to byte */
  119. #define O_CVTDW 0x69        /* convert double to word */
  120. #define O_CVTDL 0x6A        /* convert double to long */
  121. #define O_CVTRDL 0x6B        /* convert rounded double to long */
  122. #define O_CVTBD 0x6C        /* convert byte to double */
  123. #define O_CVTWD 0x6D        /* convert word to double */
  124. #define O_CVTLD 0x6E        /* convert long to double */
  125. #define O_ACBD 0x6F        /* add compare and branch double */
  126. #define O_MOVD 0x70        /* move double */
  127. #define O_CMPD 0x71        /* compare double */
  128. #define O_MNEGD 0x72        /* move negated double */
  129. #define O_TSTD 0x73        /* test double */
  130. #define O_EMODD 0x74        /* extended modulus double */
  131. #define O_POLYD 0x75        /* evaluate polynomial double */
  132. #define O_CVTDF 0x76        /* convert double to float */
  133. #define O_DUMMY77 0x77        /* RESERVED to DIGITAL */
  134. #define O_ASHL 0x78        /* arithmetic shift long */
  135. #define O_ASHQ 0x79        /* arithmetic shift quad */
  136. #define O_EMUL 0x7A        /* extended multiply */
  137. #define O_EDIV 0x7B        /* extended divide */
  138. #define O_CLRQ 0x7C        /* clear quad (also CLRD) */
  139. #define O_MOVQ 0x7D        /* move quad */
  140. #define O_MOVAQ 0x7E        /* move address of quad (also MOVAD) */
  141. #define O_PUSHAQ 0x7F        /* push address of quad (also PUSHAD) */
  142. #define O_ADDB2 0x80        /* add byte 2 operand */
  143. #define O_ADDB3 0x81        /* add byte 3 operand */
  144. #define O_SUBB2 0x82        /* subtract byte 2 operand */
  145. #define O_SUBB3 0x83        /* subtract byte 3 operand */
  146. #define O_MULB2 0x84        /* multiply byte 2 operand */
  147. #define O_MULB3 0x85        /* multiply byte 3 operand */
  148. #define O_DIVB2 0x86        /* divide byte 2 operand */
  149. #define O_DIVB3 0x87        /* divide byte 3 operand */
  150. #define O_BISB2 0x88        /* bit set byte 2 operand */
  151. #define O_BISB3 0x89        /* bit set byte 3 operand */
  152. #define O_BICB2 0x8A        /* bit clear byte 2 operand */
  153. #define O_BICB3 0x8B        /* bit clear byte 3 operand */
  154. #define O_XORB2 0x8C        /* exclusive or byte 2 operand */
  155. #define O_XORB3 0x8D        /* exclusive or byte 3 operand */
  156. #define O_MNEGB 0x8E        /* move negated byte */
  157. #define O_CASEB 0x8F        /* case byte */
  158. #define O_MOVB 0x90        /* move byte */
  159. #define O_CMPB 0x91        /* compare byte */
  160. #define O_MCOMB 0x92        /* move complemented byte */
  161. #define O_BITB 0x93        /* bit test byte */
  162. #define O_CLRB 0x94        /* clear byte */
  163. #define O_TSTB 0x95        /* test byte */
  164. #define O_INCB 0x96        /* increment byte */
  165. #define O_DECB 0x97        /* decrement byte */
  166. #define O_CVTBL 0x98        /* convert byte to long */
  167. #define O_CVTBW 0x99        /* convert byte to word */
  168. #define O_MOVZBL 0x9A        /* move zero-extended byte to long */
  169. #define O_MOVZBW 0x9B        /* move zero-extended byte to word */
  170. #define O_ROTL 0x9C        /* rotate long */
  171. #define O_ACBB 0x9D        /* add compare and branch byte */
  172. #define O_MOVAB 0x9E        /* move address of byte */
  173. #define O_PUSHAB 0x9F        /* push address of byte */
  174. #define O_ADDW2 0xA0        /* add word 2 operand */
  175. #define O_ADDW3 0xA1        /* add word 3 operand */
  176. #define O_SUBW2 0xA2        /* subtract word 2 operand */
  177. #define O_SUBW3 0xA3        /* subtract word 3 operand */
  178. #define O_MULW2 0xA4        /* multiply word 2 operand */
  179. #define O_MULW3 0xA5        /* multiply word 3 operand */
  180. #define O_DIVW2 0xA6        /* divide word 2 operand */
  181. #define O_DIVW3 0xA7        /* divide word 3 operand */
  182. #define O_BISW2 0xA8        /* bit set word 2 operand */
  183. #define O_BISW3 0xA9        /* bit set word 3 operand */
  184. #define O_BICW2 0xAA        /* bit clear word 2 operand */
  185. #define O_BICW3 0xAB        /* bit clear word 3 operand */
  186. #define O_XORW2 0xAC        /* exclusive or word 2 operand */
  187. #define O_XORW3 0xAD        /* exclusive or word 3 operand */
  188. #define O_MNEGW 0xAE        /* move negated word */
  189. #define O_CASEW 0xAF        /* case word */
  190. #define O_MOVW 0xB0        /* move word */
  191. #define O_CMPW 0xB1        /* compare word */
  192. #define O_MCOMW 0xB2        /* move complemented word */
  193. #define O_BITW 0xB3        /* bit test word */
  194. #define O_CLRW 0xB4        /* clear word */
  195. #define O_TSTW 0xB5        /* test word */
  196. #define O_INCW 0xB6        /* increment word */
  197. #define O_DECW 0xB7        /* decrement word */
  198. #define O_BISPSW 0xB8        /* bit set processor status word */
  199. #define O_BICPSW 0xB9        /* bit clear processor status word */
  200. #define O_POPR 0xBA        /* pop register */
  201. #define O_PUSHR 0xBB        /* push register */
  202. #define O_CHMK 0xBC        /* change mode to kernel */
  203. #define O_CHME 0xBD        /* change mode to executive */
  204. #define O_CHMS 0xBE        /* change mode to supervisor */
  205. #define O_CHMU 0xBF        /* change mode to user */
  206. #define O_ADDL2 0xC0        /* add long 2 operand */
  207. #define O_ADDL3 0xC1        /* add long 3 operand */
  208. #define O_SUBL2 0xC2        /* subtract long 2 operand */
  209. #define O_SUBL3 0xC3        /* subtract long 3 operand */
  210. #define O_MULL2 0xC4        /* multiply long 2 operand */
  211. #define O_MULL3 0xC5        /* multiply long 3 operand */
  212. #define O_DIVL2 0xC6        /* divide long 2 operand */
  213. #define O_DIVL3 0xC7        /* divide long 3 operand */
  214. #define O_BISL2 0xC8        /* bit set long 2 operand */
  215. #define O_BISL3 0xC9        /* bit set long 3 operand */
  216. #define O_BICL2 0xCA        /* bit clear long 2 operand */
  217. #define O_BICL3 0xCB        /* bit clear long 3 operand */
  218. #define O_XORL2 0xCC        /* exclusive or long 2 operand */
  219. #define O_XORL3 0xCD        /* exclusive or long 3 operand */
  220. #define O_MNEGL 0xCE        /* move negated long */
  221. #define O_CASEL 0xCF        /* case long */
  222. #define O_MOVL 0xD0        /* move long */
  223. #define O_CMPL 0xD1        /* compare long */
  224. #define O_MCOML 0xD2        /* move complemented long */
  225. #define O_BITL 0xD3        /* bit test long */
  226. #define O_CLRL 0xD4        /* clear long (also CLRF) */
  227. #define O_TSTL 0xD5        /* test long */
  228. #define O_INCL 0xD6        /* increment long */
  229. #define O_DECL 0xD7        /* decrement long */
  230. #define O_ADWC 0xD8        /* add with carry */
  231. #define O_SBWC 0xD9        /* subtrace with carry */
  232. #define O_MTPR 0xDA        /* move to processor register */
  233. #define O_MFPR 0xDB        /* move from processor register */
  234. #define O_MOVPSL 0xDC        /* move processor status longword */
  235. #define O_PUSHL 0xDD        /* push long */
  236. #define O_MOVAL 0xDE        /* move address of long (also MOVAF) */
  237. #define O_PUSHAL 0xDF        /* push address of long (also PUSHAF) */
  238. #define O_BBS 0xE0        /* branch on bit set */
  239. #define O_BBC 0xE1        /* branch on bit clear */
  240. #define O_BBSS 0xE2        /* branch on bit set and set */
  241. #define O_BBCS 0xE3        /* branch on bit clear and set */
  242. #define O_BBSC 0xE4        /* branch on bit set and clear */
  243. #define O_BBCC 0xE5        /* branch on bit clear and clear */
  244. #define O_BBSSI 0xE6        /* branch on bit set and set interlocked */
  245. #define O_BBCCI 0xE7        /* branch on bit clear and clear interlocked */
  246. #define O_BLBS 0xE8        /* branch on low bit set */
  247. #define O_BLBC 0xE9        /* branch on low bit clear */
  248. #define O_FFS 0xEA        /* find first set bit */
  249. #define O_FFC 0xEB        /* find first clear bit */
  250. #define O_CMPV 0xEC        /* compare field */
  251. #define O_CMPZV 0xED        /* compare zero-extended field */
  252. #define O_EXTV 0xEE        /* extract field */
  253. #define O_EXTZV 0xEF        /* extract zero-extended field */
  254. #define O_INSV 0xF0        /* insert field */
  255. #define O_ACBL 0xF1        /* add compare and branch long */
  256. #define O_AOBLSS 0xF2        /* add one and branch on less */
  257. #define O_AOBLEQ 0xF3        /* add one and branch on less or equal */
  258. #define O_SOBGEQ 0xF4        /* subtract one and branch on gtr or equal */
  259. #define O_SOBGTR 0xF5        /* subtract one and branch on greater */
  260. #define O_CVTLB 0xF6        /* convert long to byte */
  261. #define O_CVTLW 0xF7        /* convert long to word */
  262. #define O_ASHP 0xF8        /* arithmetic shift and round packed */
  263. #define O_CVTLP 0xF9        /* convert long to packed */
  264. #define O_CALLG 0xFA        /* call with general argument list */
  265. #define O_CALLS 0xFB        /* call with stack */
  266. #define O_XFC 0xFC        /* extended function call */
  267. #define O_ESCD 0xFD        /* ESCD to DIGITAL */
  268. #define O_ESCE 0xFE        /* ESCE to DIGITAL */
  269. #define O_ESCF 0xFF        /* ESCF to DIGITAL */
  270.  
  271.  
  272. typedef unsigned char VaxOpcode;
  273.  
  274. /*
  275.  * Opcode definitions.
  276.  */
  277.  
  278.  
  279. /*
  280.  * The Vax instruction decoding tables provide the following information.
  281.  * The operand access type (ACC*) specifies how an operand is used.
  282.  * The operand length specified the size of an operand.  The access
  283.  * type and length information share the same byte.  The bits used to
  284.  * construct each must be disjoint.
  285.  */
  286.  
  287. /* Access types */
  288. #define ACCR    020    /* read */
  289. #define ACCW    040    /* write */
  290. #define ACCM    060    /* modify */
  291. #define ACCB    0100    /* branch displacement */
  292. #define ACCI    0120    /* variable field */
  293. #define ACCA    0140    /* address only */
  294.  
  295. /* Argument lengths.  These correspond to T_* values in vartab.h */
  296. #define TYPB    0    /* byte */
  297. #define TYPUB   1    /* unsigned byte */
  298. #define TYPW    2    /* word */
  299. #define TYPUW   3       /* unsigned word */
  300. #define TYPL    4    /* long */
  301. #define TYPUL   5       /* unsigned long */
  302. #define TYPF    8    /* floating */
  303. #define TYPD    10    /* double floating */
  304. #define TYPQ    12    /* quad */
  305. #define TYPS    14      /* subroutine (func) */
  306.  
  307. /*
  308.  * The following constants represent addressing modes.  The addressing
  309.  * modes are stored in the upper nibble of the operand byte.  The lower
  310.  * nibble normally contains a register number.
  311.  */
  312.  
  313. #define LITSHORT    0x0    /* short literals */
  314. #define LITUPTO31   0x1
  315. #define LITUPTO47   0x2
  316. #define LITUPTO63   0x3
  317. #define INDEX       0x4 /* i[r] */
  318. #define REG        0x5 /* r */
  319. #define REGDEF      0x6 /* (r) */
  320. #define AUTODEC     0x7 /* -(r) */
  321. #define AUTOINC     0x8 /* (r)+ */
  322. #define AUTOINCDEF  0x9 /* *(r)+ */
  323. #define BYTEDISP    0xA /* BD(r) */
  324. #define BYTEDISPDEF 0xB /* *BD(r) */
  325. #define WORDDISP    0xC /* WD(r) */
  326. #define WORDDISPDEF 0xD /* *WD(r) */
  327. #define LONGDISP    0xE /* LD(r) */
  328. #define LONGDISPDEF 0xF /* *LD(r) */
  329.  
  330. #define acctype(arg)        ((arg) & 0160)
  331. #define typelen(arg)        ((arg) & 017)
  332. #define regnm(mode)        ((mode) & 0xF)
  333. #define addrmode(mode)      ((mode) >> 4)
  334.  
  335. #define is_branch_disp(arg) (acctype(arg) == ACCB)
  336.  
  337. /* Print formatting types */
  338.  
  339. #define MACRO 0            /* print macro code */
  340. #define A1OPA0 1        /* arg1 <op> arg 0; */
  341. #define A2EQ1OP0 2        /* arg2 = arg1 <op> arg0; */
  342. #define A0OP 3            /* arg0 <op> */
  343. #define OPONLY 4        /* <op> */
  344. #define CALLS 5            /* @val@ = arg1( @arg0 args@ ); */
  345. #define PUSH 6            /* @arg@ = arg0; */
  346. #define PUSHA 7            /* @arg@ = &arg0; */
  347. #define EXTZV 8            /* arg3 = (arg2 >> arg0) & mask(arg1) */
  348. #define COMP 9            /* cmp instruction */
  349. #define TEST 10            /* tst instruction */
  350. #define BBRANCH 11        /* bit test and branch */
  351. #define CBRANCH 12        /* conditional branch */
  352.  
  353. /*
  354.  * The file ops.c contains a table of the following structure with an
  355.  * entry for each Vax opcode.
  356.  */
  357. struct opcode {
  358.     int coptype;        /* the print formatting type */
  359.     char *cop1;            /* C operand source string */
  360.     char numargs;        /* the number of operands */
  361.     char argtype[6];        /* the operand type of each operand */
  362. };
  363.  
  364. /*
  365.  * define the global tables in ops.c
  366.  */
  367. extern struct opcode opcode[];    /* the opcode table */
  368. extern char *fltimm[];        /* immediate float values */
  369.